package com.wangchenyang.common.redis.utils;

import com.wangchenyang.common.core.util.SpringContextHolder;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import org.redisson.api.*;
import org.redisson.config.Config;

import java.time.Duration;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * redis 工具类
 *
 */
@NoArgsConstructor(access = AccessLevel.PRIVATE)
@SuppressWarnings(value = { "unchecked", "rawtypes" })
public class RedisUtils {

	private static final RedissonClient CLIENT = SpringContextHolder.getBean(RedissonClient.class);

	public static NameMapper getNameMapper() {
		Config config = CLIENT.getConfig();
		if (config.isClusterConfig()) {
			return config.useClusterServers().getNameMapper();
		}
		return config.useSingleServer().getNameMapper();
	}

	/**
	 * 限流
	 * @param key 限流key
	 * @param rateType 限流类型
	 * @param rate 速率
	 * @param rateInterval 速率间隔
	 * @return -1 表示失败
	 */
	public static long rateLimiter(String key, RateType rateType, int rate, int rateInterval) {
		RRateLimiter rateLimiter = CLIENT.getRateLimiter(key);
		rateLimiter.trySetRate(rateType, rate, rateInterval, RateIntervalUnit.SECONDS);
		if (rateLimiter.tryAcquire()) {
			return rateLimiter.availablePermits();
		}
		else {
			return -1L;
		}
	}

	/**
	 * 获取客户端实例
	 */
	public static RedissonClient getClient() {
		return CLIENT;
	}

	/**
	 * 发布通道消息
	 * @param channelKey 通道key
	 * @param msg 发送数据
	 * @param consumer 自定义处理
	 */
	public static <T> void publish(String channelKey, T msg, Consumer<T> consumer) {
		RTopic topic = CLIENT.getTopic(channelKey);
		topic.publish(msg);
		consumer.accept(msg);
	}

	public static <T> void publish(String channelKey, T msg) {
		RTopic topic = CLIENT.getTopic(channelKey);
		topic.publish(msg);
	}

	/**
	 * 订阅通道接收消息
	 * @param channelKey 通道key
	 * @param clazz 消息类型
	 * @param consumer 自定义处理
	 */
	public static <T> void subscribe(String channelKey, Class<T> clazz, Consumer<T> consumer) {
		RTopic topic = CLIENT.getTopic(channelKey);
		topic.addListener(clazz, (channel, msg) -> consumer.accept(msg));
	}

	/**
	 * 缓存基本的对象，Integer、String、实体类等
	 * @param key 缓存的键值
	 * @param value 缓存的值
	 */
	public static <T> void setCacheObject(final String key, final T value) {
		setCacheObject(key, value, false);
	}

	/**
	 * 缓存基本的对象，保留当前对象 TTL 有效期
	 * @param key 缓存的键值
	 * @param value 缓存的值
	 * @param isSaveTtl 是否保留TTL有效期(例如: set之前ttl剩余90 set之后还是为90)
	 * @since Redis 6.X 以上使用 setAndKeepTTL 兼容 5.X 方案
	 */
	public static <T> void setCacheObject(final String key, final T value, final boolean isSaveTtl) {
		RBucket<T> bucket = CLIENT.getBucket(key);
		if (isSaveTtl) {
			try {
				bucket.setAndKeepTTL(value);
			}
			catch (Exception e) {
				long timeToLive = bucket.remainTimeToLive();
				setCacheObject(key, value, Duration.ofMillis(timeToLive));
			}
		}
		else {
			bucket.set(value);
		}
	}

	/**
	 * 缓存基本的对象，Integer、String、实体类等
	 * @param key 缓存的键值
	 * @param value 缓存的值
	 * @param duration 时间
	 */
	public static <T> void setCacheObject(final String key, final T value, final Duration duration) {
		RBatch batch = CLIENT.createBatch();
		RBucketAsync<T> bucket = batch.getBucket(key);
		bucket.setAsync(value);
		bucket.expireAsync(duration);
		batch.execute();
	}

	/**
	 * 注册对象监听器
	 * <p>
	 * key 监听器需开启 `notify-keyspace-events` 等 redis 相关配置
	 * @param key 缓存的键值
	 * @param listener 监听器配置
	 */
	public static <T> void addObjectListener(final String key, final ObjectListener listener) {
		RBucket<T> result = CLIENT.getBucket(key);
		result.addListener(listener);
	}

	/**
	 * 设置有效时间
	 * @param key Redis键
	 * @param timeout 超时时间
	 * @return true=设置成功；false=设置失败
	 */
	public static boolean expire(final String key, final long timeout) {
		return expire(key, Duration.ofSeconds(timeout));
	}

	/**
	 * 设置有效时间
	 * @param key Redis键
	 * @param duration 超时时间
	 * @return true=设置成功；false=设置失败
	 */
	public static boolean expire(final String key, final Duration duration) {
		RBucket rBucket = CLIENT.getBucket(key);
		return rBucket.expire(duration);
	}

	/**
	 * 获得缓存的基本对象。
	 * @param key 缓存键值
	 * @return 缓存键值对应的数据
	 */
	public static <T> T getCacheObject(final String key) {
		RBucket<T> rBucket = CLIENT.getBucket(key);
		return rBucket.get();
	}

	/**
	 * 获得key剩余存活时间
	 * @param key 缓存键值
	 * @return 剩余存活时间
	 */
	public static <T> long getTimeToLive(final String key) {
		RBucket<T> rBucket = CLIENT.getBucket(key);
		return rBucket.remainTimeToLive();
	}

	/**
	 * 删除单个对象
	 * @param key 缓存的键值
	 */
	public static boolean deleteObject(final String key) {
		return CLIENT.getBucket(key).delete();
	}

	/**
	 * 删除集合对象
	 * @param collection 多个对象
	 */
	public static void deleteObject(final Collection collection) {
		RBatch batch = CLIENT.createBatch();
		collection.forEach(t -> {
			batch.getBucket(t.toString()).deleteAsync();
		});
		batch.execute();
	}

	/**
	 * 缓存List数据
	 * @param key 缓存的键值
	 * @param dataList 待缓存的List数据
	 * @return 缓存的对象
	 */
	public static <T> boolean setCacheList(final String key, final List<T> dataList) {
		RList<T> rList = CLIENT.getList(key);
		return rList.addAll(dataList);
	}

	/**
	 * 注册List监听器
	 * <p>
	 * key 监听器需开启 `notify-keyspace-events` 等 redis 相关配置
	 * @param key 缓存的键值
	 * @param listener 监听器配置
	 */
	public static <T> void addListListener(final String key, final ObjectListener listener) {
		RList<T> rList = CLIENT.getList(key);
		rList.addListener(listener);
	}

	/**
	 * 获得缓存的list对象
	 * @param key 缓存的键值
	 * @return 缓存键值对应的数据
	 */
	public static <T> List<T> getCacheList(final String key) {
		RList<T> rList = CLIENT.getList(key);
		return rList.readAll();
	}

	/**
	 * 缓存Set
	 * @param key 缓存键值
	 * @param dataSet 缓存的数据
	 * @return 缓存数据的对象
	 */
	public static <T> boolean setCacheSet(final String key, final Set<T> dataSet) {
		RSet<T> rSet = CLIENT.getSet(key);
		return rSet.addAll(dataSet);
	}

	/**
	 * 注册Set监听器
	 * <p>
	 * key 监听器需开启 `notify-keyspace-events` 等 redis 相关配置
	 * @param key 缓存的键值
	 * @param listener 监听器配置
	 */
	public static <T> void addSetListener(final String key, final ObjectListener listener) {
		RSet<T> rSet = CLIENT.getSet(key);
		rSet.addListener(listener);
	}

	/**
	 * 获得缓存的set
	 * @param key 缓存的key
	 * @return set对象
	 */
	public static <T> Set<T> getCacheSet(final String key) {
		RSet<T> rSet = CLIENT.getSet(key);
		return rSet.readAll();
	}

	/**
	 * 缓存Map
	 * @param key 缓存的键值
	 * @param dataMap 缓存的数据
	 */
	public static <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
		if (dataMap != null) {
			RMap<String, T> rMap = CLIENT.getMap(key);
			rMap.putAll(dataMap);
		}
	}

	/**
	 * 注册Map监听器
	 * <p>
	 * key 监听器需开启 `notify-keyspace-events` 等 redis 相关配置
	 * @param key 缓存的键值
	 * @param listener 监听器配置
	 */
	public static <T> void addMapListener(final String key, final ObjectListener listener) {
		RMap<String, T> rMap = CLIENT.getMap(key);
		rMap.addListener(listener);
	}

	/**
	 * 获得缓存的Map
	 * @param key 缓存的键值
	 * @return map对象
	 */
	public static <T> Map<String, T> getCacheMap(final String key) {
		RMap<String, T> rMap = CLIENT.getMap(key);
		return rMap.getAll(rMap.keySet());
	}

	/**
	 * 往Hash中存入数据
	 * @param key Redis键
	 * @param hKey Hash键
	 * @param value 值
	 */
	public static <T> void setCacheMapValue(final String key, final String hKey, final T value) {
		RMap<String, T> rMap = CLIENT.getMap(key);
		rMap.put(hKey, value);
	}

	/**
	 * 获取Hash中的数据
	 * @param key Redis键
	 * @param hKey Hash键
	 * @return Hash中的对象
	 */
	public static <T> T getCacheMapValue(final String key, final String hKey) {
		RMap<String, T> rMap = CLIENT.getMap(key);
		return rMap.get(hKey);
	}

	/**
	 * 删除Hash中的数据
	 * @param key Redis键
	 * @param hKey Hash键
	 * @return Hash中的对象
	 */
	public static <T> T delCacheMapValue(final String key, final String hKey) {
		RMap<String, T> rMap = CLIENT.getMap(key);
		return rMap.remove(hKey);
	}

	/**
	 * 获取多个Hash中的数据
	 * @param key Redis键
	 * @param hKeys Hash键集合
	 * @return Hash对象集合
	 */
	public static <K, V> Map<K, V> getMultiCacheMapValue(final String key, final Set<K> hKeys) {
		RMap<K, V> rMap = CLIENT.getMap(key);
		return rMap.getAll(hKeys);
	}

	/**
	 * 设置原子值
	 * @param key Redis键
	 * @param value 值
	 */
	public static void setAtomicValue(String key, long value) {
		RAtomicLong atomic = CLIENT.getAtomicLong(key);
		atomic.set(value);
	}

	/**
	 * 获取原子值
	 * @param key Redis键
	 * @return 当前值
	 */
	public static long getAtomicValue(String key) {
		RAtomicLong atomic = CLIENT.getAtomicLong(key);
		return atomic.get();
	}

	/**
	 * 递增原子值
	 * @param key Redis键
	 * @return 当前值
	 */
	public static long incrAtomicValue(String key) {
		RAtomicLong atomic = CLIENT.getAtomicLong(key);
		return atomic.incrementAndGet();
	}

	/**
	 * 递减原子值
	 * @param key Redis键
	 * @return 当前值
	 */
	public static long decrAtomicValue(String key) {
		RAtomicLong atomic = CLIENT.getAtomicLong(key);
		return atomic.decrementAndGet();
	}

	/**
	 * 获得缓存的基本对象列表
	 * @param pattern 字符串前缀
	 * @return 对象列表
	 */
	public static Collection<String> keys(final String pattern) {
		Stream<String> stream = CLIENT.getKeys().getKeysStreamByPattern(getNameMapper().map(pattern));
		return stream.map(key -> getNameMapper().unmap(key)).collect(Collectors.toList());
	}

	/**
	 * 删除缓存的基本对象列表
	 * @param pattern 字符串前缀
	 */
	public static void deleteKeys(final String pattern) {
		CLIENT.getKeys().deleteByPattern(getNameMapper().map(pattern));
	}

	/**
	 * 检查redis中是否存在key
	 * @param key 键
	 */
	public static Boolean hasKey(String key) {
		RKeys rKeys = CLIENT.getKeys();
		return rKeys.countExists(getNameMapper().map(key)) > 0;
	}

}
